{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ML_in_Finance_FCW\n",
    "# Author: Matthew Dixon\n",
    "# Version: 1.0 (06.05.2020)\n",
    "# License: MIT\n",
    "# Email: matthew.dixon@iit.edu\n",
    "# Notes: tested on Mac OS X with Python 3.6.9 and the following packages:\n",
    "# matplotlib=3.1.3, numpy=1.18.1, tqdm=4.46.0\n",
    "# Citation: Please cite the following reference if this notebook is used for research purposes:\n",
    "# Bilokon P., Dixon M.F. and Halperin I., Machine Learning in Finance: From Theory to Practice, Springer Graduate textbook Series, 2020. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adapted from the code referenced here:\n",
    "# https://github.com/ShangtongZhang/reinforcement-learning-an-introduction\n",
    "#######################################################################\n",
    "# Copyright (C)                                                       #\n",
    "# 2016-2018 Shangtong Zhang(zhangshangtong.cpp@gmail.com)             #\n",
    "# 2016 Kenta Shimada(hyperkentakun@gmail.com)                         #\n",
    "# Permission given to modify the code as long as you keep this        #\n",
    "# declaration at the top                                              #\n",
    "#######################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Financial Cliff Walking Problem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider an over-simplified model of a household's finances. Let $S_t$ be the amount of money the household has at time $t$. We assume for simplicity that $S_t$ can only take values in a discrete set $\\{S^{(i)}\\}_{i=0}^{N-1}$. \n",
    "\n",
    "The account has to be maintained for $T$ time steps, after which it should be closed - $T$ is the planning horizon. The zero-level $S^{(0)}=0$ is a bankruptcy level - it has to be avoided, as reaching it means inability to pay on household liabilities. \n",
    "\n",
    "At each step, the agent can deposit to the account $S^{(i)} \\rightarrow S^{(i+1)}$ (action $a_+$), withdraw from the account $S^{(i)} \\rightarrow S^{(i-1)}$, (action $a_-$), or keep the same amount $S^{(i)} \\rightarrow S^{(i)}$, (action $a_0$). The initial amount in the account is zero. \n",
    "\n",
    "For any step before the final step $T$, if the agent moves to the zero level  $S_0 = 0$, it gets a negative reward of $-100$, and the episode terminates. Otherwise, it continues for all $T$ steps. Any action not leading to the zero level gets a negative reward of $-1$. At $T$, if the final state is $S_T>0$, the reward is $-10$, but if the account goes back to zero exactly at time $T$, i.e. $S_T=0$, then the last action gets a positive reward of $+10$. \n",
    "\n",
    "The learning task is to maximize the total reward over $T$ time steps. The RL agent has to learn the optimal depository policy online by trying different actions during a training episode. Note that while this is a time-dependent problem, we can map it on to a stationary problem with an episodic task and a target state, such as the original cliff walking problem in Sutton-Barto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"The-cliff-walking-task.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import the necessary libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt \n",
    "\n",
    "from tqdm import tqdm "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setting Up"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We assume $N=4$ values of possible funds in the account, and assume $T=12$ time steps. All combinations of state and time can then be represented as a two-dimensional grid of size $N\\times T = 4\\times 12$. A time dependent action value function $Q_t\\left( s_t, a_t\\right)$ with three possible actions, $a_t = \\left\\{a_+, a_-, a_0\\right\\}$, can then be stored as a rank three tensor of dimension $4\\times 12 \\times 3$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set global parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "WORLD_HEIGHT = 4 # The number of states\n",
    "WORLD_WIDTH = 12 # The number of time steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "EPSILON = 0.1 # Probability for exploration\n",
    "\n",
    "ALPHA = 0.001 # Step size\n",
    "\n",
    "GAMMA = 1 # Discount factor for Q-Learning, Sarsa and Expected Sarsa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We assign an integer value representing each action to a variable: `ACTION_UP` is $a_+$ (adding a deposit), `ACTION_DOWN` is $a_-$ (redeeming a deposit) and `ACTION_ZERO` is $a_0$ (leaving the account as it is)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "ACTION_UP = 1\n",
    "ACTION_DOWN = 2\n",
    "ACTION_ZERO = 0\n",
    "ACTIONS = [ACTION_UP, ACTION_DOWN, ACTION_ZERO]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We define the state vectors for the initial and goal states"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "START = [0, 0]\n",
    "GOAL = [0, WORLD_WIDTH-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setting up the environment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The step function that describes how the next state is obtained from the current state and the action taken. The function returns the next state and the reward obtained."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def step(state, action):\n",
    "    i, j = state\n",
    "\n",
    "    if action == ACTION_UP:\n",
    "        next_state = [min(i + 1, WORLD_HEIGHT-1), min(j + 1, WORLD_WIDTH - 1)]\n",
    "    elif action == ACTION_DOWN:\n",
    "        next_state = [max(i - 1, 0), min(j + 1, WORLD_WIDTH - 1)]\n",
    "    elif action == ACTION_ZERO:\n",
    "        next_state = [i, min(j + 1, WORLD_WIDTH - 1)]\n",
    "    else:\n",
    "        raise ValueError(\"action not recognised\")\n",
    "    \n",
    "    # The reward is -1 for actions ACTION_UP and ACTION_DOWN. \n",
    "    # This is done to keep transactions to a minimum.\n",
    "    reward = -1\n",
    "    \n",
    "    # ACTION_ZERO gets a zero reward since we want to minimize the number of transactions\n",
    "    if action == ACTION_ZERO:\n",
    "        reward = 0\n",
    "    \n",
    "    # Exceptions are \n",
    "    # i) If bankruptcy happens before WORLD_WIDTH time steps\n",
    "    # ii) No deposit at initial state\n",
    "    # iii) Redemption at initial state!\n",
    "    # iv) Any action carried out from a bankrupt state\n",
    "    if ((action == ACTION_DOWN and i == 1 and 1 <= j < 10) or (\n",
    "        action == ACTION_ZERO and state == START) or (\n",
    "        action == ACTION_DOWN and state == START )) or (\n",
    "        i == 0 and 1 <= j <= 10):    \n",
    "            reward = -100\n",
    "        \n",
    "    # Next exception is when we get to the final time step.\n",
    "    if (next_state[1] == WORLD_WIDTH - 1): \n",
    "        if (next_state[0] == 0): # Action resulted in ending with zero balance in final time step\n",
    "            reward = 10\n",
    "        else:\n",
    "            reward = -10   \n",
    "        \n",
    "    return next_state, reward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "([1, 1], -1)\n",
      "([1, 4], -1)\n",
      "([0, 6], -100)\n"
     ]
    }
   ],
   "source": [
    "# Check some state, action pairs and the associated reward\n",
    "print(step([0, 0], ACTION_UP))\n",
    "print(step([2, 3], ACTION_DOWN))\n",
    "print(step([1, 5], ACTION_DOWN))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set up the agent's action policy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given $S_t$ and $Q_t\\left( s_t, a_t\\right)$, this function chooses an action based on the epsilon-greedy algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def choose_action(state, q_value, eps=EPSILON):\n",
    "    # With probability `eps', simply choose a random action - 'Exploration'\n",
    "    if np.random.binomial(1, eps) == 1:\n",
    "        action = np.random.choice(ACTIONS)\n",
    "    # Otherwise, choose from the actions with the highest\n",
    "    # q-value for the given state - 'Exploitation'\n",
    "    else:\n",
    "        values_ = q_value[state[0], state[1], :]\n",
    "        action = np.random.choice(\n",
    "            [action_ for action_, value_ in enumerate(values_) \n",
    "                                if value_ == np.max(values_)])\n",
    "    # From the bankrupt state there is no meaningful action, \n",
    "    # so we will assign ACTION_ZERO by convention.\n",
    "    if state[0] == 0 and state[1] > 0:\n",
    "        action = ACTION_ZERO\n",
    "    return action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe the effect of $Q_t\\left( s_t, a_t\\right)$ & $\\epsilon$ on the distribution of actions taken from a given state: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "# If q_value contains only zeroes, the action is always random\n",
    "q_value = np.zeros((WORLD_HEIGHT, WORLD_WIDTH, len(ACTIONS)))\n",
    "print(choose_action([0, 2], q_value, EPSILON))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "action with highest q for state=[1, 4]: 2\n",
      "choices (eps=0): 2 2 2 2 2 2 2 2 2 2\n",
      "choices (eps=1): 2 0 0 1 2 0 1 0 0 2\n",
      "\n",
      "action with highest q for state=[2, 7]: 0\n",
      "choices (eps=0):   0 0 0 0 0 0 0 0 0 0\n",
      "choices (eps=0.5): 0 2 0 0 0 0 0 0 0 2\n"
     ]
    }
   ],
   "source": [
    "q_value = np.zeros((WORLD_HEIGHT, WORLD_WIDTH, len(ACTIONS)))\n",
    "q_value[1, 4, 2] = 1\n",
    "print('action with highest q for state=[1, 4]:', np.argmax(q_value[1, 4]))\n",
    "print('choices (eps=0):', *[choose_action([1, 4], q_value, 0) for i in range(10)])\n",
    "print('choices (eps=1):', *[choose_action([1, 4], q_value, 1) for i in range(10)])\n",
    "\n",
    "q_value[2, 7, 0] = 1\n",
    "print('\\naction with highest q for state=[2, 7]:', np.argmax(q_value[2, 7]))\n",
    "print('choices (eps=0):  ', *[choose_action([2, 7], q_value, 0) for i in range(10)])\n",
    "print('choices (eps=0.5):', *[choose_action([2, 7], q_value, 0.5) for i in range(10)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set up the learning algorithms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sarsa and Expected Sarsa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function simulates an episode with Sarsa. It takes the state-action value array `q_value` as an argument, initialises the state to `START`, defined above, and updates `q_value` according to the Sarsa algorithm, until the $T$ time steps have passed, or the bankrupt state is reached. The cumulative reward earned is returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sarsa(q_value, expected=False, step_size=ALPHA, eps=EPSILON):\n",
    "    state = START\n",
    "    action = choose_action(state, q_value, eps)\n",
    "    rewards = 0.0\n",
    "    \n",
    "    while (state[1] != WORLD_WIDTH-1) and not(1 <= state[1] <= 10 and state[0]==0):\n",
    "        next_state, reward = step(state, action)\n",
    "        next_action = choose_action(next_state, q_value, eps)\n",
    "        rewards += reward\n",
    "        if not expected:\n",
    "            target = q_value[next_state[0], next_state[1], next_action]\n",
    "        else:\n",
    "            # Calculate the expected value of the new state\n",
    "            target = 0.0\n",
    "            q_next = q_value[next_state[0], next_state[1], :]\n",
    "            best_actions = np.argwhere(q_next == np.max(q_next))\n",
    "            for action_ in ACTIONS:\n",
    "                if action_ in best_actions:\n",
    "                    target += ((1.0 - eps) / len(best_actions) \n",
    "                               + eps / len(ACTIONS)) * q_value[next_state[0], next_state[1], action_]\n",
    "                else:\n",
    "                    target += eps / len(ACTIONS) * q_value[next_state[0], next_state[1], action_]\n",
    "        target *= GAMMA\n",
    "        q_value[state[0], state[1], action] += step_size * (\n",
    "                reward + target - q_value[state[0], state[1], action])\n",
    "        state = next_state\n",
    "        action = next_action\n",
    "    return rewards"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q-learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function simulates an episode with Q-learning. It takes the state-action value array `q_value` as an argument, initialises the state to `START`, defined above, and updates `q_value` according to the Q-learning algorithm, until the $T$ time steps have passed, or the bankrupt state is reached. The cumulative reward earned is returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def q_learning(q_value, step_size=ALPHA, eps=EPSILON):\n",
    "    state = START\n",
    "    rewards = 0.0\n",
    "    while state[1] != WORLD_WIDTH-1 and not(1 <= state[1] <= 10 and state[0]==0):\n",
    "        action = choose_action(state, q_value, eps)\n",
    "        next_state, reward = step(state, action)\n",
    "        rewards += reward\n",
    "        # Q-Learning update\n",
    "        q_value[state[0], state[1], action] += step_size * (\n",
    "                reward + GAMMA * np.max(q_value[next_state[0], next_state[1], :]) -\n",
    "                q_value[state[0], state[1], action])\n",
    "        state = next_state\n",
    "    return rewards"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set up the epsilon decay"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We decrease the value of epsilon with each epoch - epsilon must approach zero as the number of episodes increases in order to ensure that the q-value function converges to the optimum with the SARSA algorithm\n",
    "\n",
    "The following figure demonstrates the exponential decay we are going to use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10f5de748>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot([ EPSILON*((1-EPSILON)**(i//40)) for i in range(2000)])\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Epsilon');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running Sarsa and Q-learning to compare their asymptotic behaviour"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function will plot the average (over `runs` independent trials) rewards earned by SARSA and Q-learning after each iteration (up to `episodes`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sarsa converges to the safe path, while Q-Learning converges to the optimal path\n",
    "def figure_9_4():\n",
    "    # Number of episodes in each run\n",
    "    episodes = 1500\n",
    "    EPOCH = 40\n",
    "\n",
    "    # Perform 100 independent runs\n",
    "    runs = 100\n",
    "    \n",
    "    # Initialise the rewards arrays\n",
    "    rewards_sarsa = np.zeros(episodes)\n",
    "    rewards_q_learning = np.zeros(episodes)\n",
    "    for r in tqdm(range(runs)):\n",
    "        # Initialise the action value arrays \n",
    "        q_sarsa = np.zeros((WORLD_HEIGHT, WORLD_WIDTH, len(ACTIONS)))\n",
    "        q_q_learning = np.copy(q_sarsa)\n",
    "        \n",
    "        # Update the rewards and action value arrays for each episode\n",
    "        for i in range(0, episodes):\n",
    "            # The value of epsilon is decremented exponentially\n",
    "            # after every EPOCH episodes\n",
    "            eps = EPSILON*((1-EPSILON)**(i//EPOCH))\n",
    "            rewards_sarsa[i] += sarsa(q_sarsa, eps=eps)\n",
    "            rewards_q_learning[i] += q_learning(q_q_learning, eps=eps)\n",
    "\n",
    "    # Averaging over independent runs\n",
    "    rewards_sarsa /= runs\n",
    "    rewards_q_learning /= runs\n",
    "\n",
    "    # Draw reward curves\n",
    "    plt.figure(figsize=(15,7))\n",
    "    plt.plot(rewards_sarsa, label='Sarsa')\n",
    "    plt.plot(rewards_q_learning, label='Q-Learning')\n",
    "    plt.xlabel('Episodes')\n",
    "    plt.ylabel('Sum of rewards during episode')\n",
    "    plt.ylim([-100, 20])\n",
    "    plt.legend()\n",
    "\n",
    "    return q_sarsa, q_q_learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [06:24<00:00,  3.84s/it]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11b3abe48>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "q_sarsa, q_q_learning = figure_9_4()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Printing output of the learned policies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_optimal_policy(q_value):\n",
    "    optimal_policy = []\n",
    "    for i in range(WORLD_HEIGHT-1, -1, -1):\n",
    "        optimal_policy.append([])\n",
    "        for j in range(0, WORLD_WIDTH):\n",
    "            if [i, j] == GOAL:\n",
    "                optimal_policy[-1].append('G')\n",
    "                continue\n",
    "            bestAction = np.argmax(q_value[i, j, :])\n",
    "            \n",
    "            # Action in bankrupt state has been set as Z\n",
    "            if i == 0 and j > 0 and j < WORLD_WIDTH-1:\n",
    "                optimal_policy[-1].append('Z')\n",
    "            elif bestAction == ACTION_UP:\n",
    "                # When i = WORLDHEIGHT - 1, U and Z are identical, so we will use Z\n",
    "                if i == WORLD_HEIGHT-1:\n",
    "                    optimal_policy[-1].append('Z')\n",
    "                else:\n",
    "                    optimal_policy[-1].append('U')\n",
    "            elif bestAction == ACTION_DOWN:\n",
    "                optimal_policy[-1].append('D')\n",
    "            elif bestAction == ACTION_ZERO:\n",
    "                optimal_policy[-1].append('Z')\n",
    "    \n",
    "    for row in optimal_policy:\n",
    "        print(row)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sarsa Optimal Policy:\n",
      "['Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z']\n",
      "['Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'D', 'U', 'Z']\n",
      "['Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'D', 'Z']\n",
      "['U', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'G']\n",
      "Q-Learning Optimal Policy:\n",
      "['Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z']\n",
      "['Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'D', 'Z', 'Z']\n",
      "['Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'D', 'Z']\n",
      "['U', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'G']\n"
     ]
    }
   ],
   "source": [
    "print('Sarsa Optimal Policy:')\n",
    "print_optimal_policy(q_sarsa)\n",
    "print('Q-Learning Optimal Policy:')\n",
    "print_optimal_policy(q_q_learning)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
